package com.shujia.scala

object Demo20List {
  def main(args: Array[String]): Unit = {
    /**
      * list ： 有序不唯一
      * set  ： 无序唯一
      * Map : kv格式
      * Tuple : 元组， 固定长度的集合
      *
      */

    //构建list
    //不可变的list
    val list = List(1, 2, 3, 4, 5, 6, 6, 7, 8, 9)

    //通过下标获取数据
    println(list(4))
    //获取头
    println(list.head)
    //获取最后一个元素
    println(list.last)
    //取top
    println(list.take(2))
    //获取不包含第一个元素的所有元素
    println(list.tail)
    //判断是否为空
    println(list.isEmpty)
    //返回集合，返回一个新的集合
    println(list.reverse)
    //去重
    println(list.distinct)
    //将集合构建成一个字符串，指定分割方式
    //和split相反
    println(list.mkString(","))
    //判断是否包含某一个元素
    println(list.contains(1))
    println("=" * 100)
    //求和
    println(list.sum)
    //取最大值
    println(list.max)
    //取最小值
    println(list.min)
    println("=" * 100)

    /**
      * foreach
      *
      */
    list.foreach(println)


    /**
      * map: 将集合中的元素一个一个传递给后面的函数，函数的返回值构建成一个新的集合
      * 传入一行返回一行
      */

    val list2: List[Int] = list.map((i: Int) => i + 100)
    println(list2)

    /**
      * filter: 对数据进行过滤
      * 将集合中元素一个一个传递给后面的函数
      * 如果函数返回True保留数据
      * 如果函数返回False过滤数据
      *
      */

    //取出所有的奇数
    val filterList: List[Int] = list.filter((i: Int) => {
      i % 2 == 1
    })
    println(filterList)


    /**
      * sortBy: 指定一个字段对数据进行排序， 默认是升序
      *
      */
    val list3 = List(1, 2, 3, 1, 23, 12, 412, 3, 2, 12, 321, 4, 12, 312)

    val sortList: List[Int] = list3.sortBy((i: Int) => -i)

    println(sortList)


    /**
      * sortWith： 传入一个比较规则
      *
      */
    val sortList2: List[Int] = list3.sortWith((i: Int, j: Int) => i > j)

    println(sortList2)


    println("=" * 100)
    /**
      *
      *
      */

    val lines: List[String] = List("java,spark,hadoop", "hadoop,spark,hive", "scala,hive,java,hadoop")

    //java的方式
    for (line <- lines) {
      val split: Array[String] = line.split(",")
      //split.foreach(println)
    }

    /**
      * flatMap: 将集合中的元素一个一个传递给后面的函数
      * 函数的返回值必须是一个集合
      * 后将返回的集合展开成一个新的集合
      *
      * 将一行数据转换多行数据
      *
      * 相当于sql中的explode
      *
      */
    lines.foreach(println)

    val words: List[String] = lines.flatMap((line: String) => line.split(","))

    words.foreach(println)

    /**
      * groupBy: 指定一个字段进行分组，返回一个Map结构的集合
      *
      */

    val list5 = List(1, 2, 3, 4, 1, 1, 2, 4, 4, 1, 2, 4, 4, 1)

    val groupBy: Map[Int, List[Int]] = list5.groupBy((i: Int) => i)

    groupBy.foreach(println)


    /**
      * foreach: 循环遍历，没有返回值
      * map: 对集合中的数据进行处理，返回一个新的集合
      * filter : 对集合中的数据进行过滤
      * sortBy： 指定一个字段进行排序
      * flatMap : 将一行数据拆分成多行数据
      * groupBy : 指定一个字段进行分组
      *
      */

  }

}
